///////////////////////////////////////////////////////////////////////////////
//  File:       SmartDict.cpp
//
//  Summary:    Smart pointer classes for Dictionary/Simplelist that do
//              error handling.
//
//  Sample:     CSF Headlines
//
//---------------------------------------------------------------------
//  This file is part of the Microsoft Commerce Server 2002 SDK
//
//  Copyright (C) 2000 - 2001 Microsoft Corporation.  All rights reserved.
//
// This source code is intended only as a supplement to Microsoft
// Commerce Server 2002 and/or on-line documentation. See these other
// materials for detailed information regarding Microsoft code samples. 
//
// THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
// KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
///////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "smartdict.h"
#include "resource.h"


// Error Messages
const int g_maxErrorMsgSize = 2048;     // max error message size
const int g_intBufferSize = 15;         // buffer size for formatting integers into strings


// Dictionary Errors

void CSmartHelperBase::ErrMissingValue(BSTR bstrName, VARTYPE vt)
{
    WCHAR errText[g_maxErrorMsgSize];

    if (LoadString(HELPER_GETDLLINSTANCE_METHOD, IDS_DICTUTIL_ERRDICTMISSING, errText, sizeof(errText)))
    {
        CComBSTR bstrError;
        bstrError.Attach(SysAllocStringLen(NULL, wcslen(errText) + SysStringLen(bstrName) + wcslen(m_wszObjName) + g_intBufferSize));
        if (bstrError)
        {
            wsprintf(bstrError, errText, bstrName, m_wszObjName, (int)vt);
            AtlReportError(CLSID_CDictionary, bstrError, IID_IDictionary, 0);
        }
    }
}

void CSmartHelperBase::ErrMissingValue(BSTR bstrName)
{
    WCHAR errText[g_maxErrorMsgSize];

    if (LoadString(HELPER_GETDLLINSTANCE_METHOD, IDS_DICTUTIL_ERRDICTMISSINGNOTYPE, errText, sizeof(errText)))
    {
        CComBSTR bstrError;
        bstrError.Attach(SysAllocStringLen(NULL, wcslen(errText) + SysStringLen(bstrName) + wcslen(m_wszObjName) + 10));
        if (bstrError)
        {
            wsprintf(bstrError, errText, bstrName, m_wszObjName);
            AtlReportError(CLSID_CDictionary, bstrError, IID_IDictionary, 0);
        }
    }
}

void CSmartHelperBase::ErrValueWrongType(BSTR bstrName, VARTYPE vtExpected, VARTYPE vtGot)
{
    WCHAR errText[g_maxErrorMsgSize];

    if (LoadString(HELPER_GETDLLINSTANCE_METHOD, IDS_DICTUTIL_ERRDICTTYPE, errText, sizeof(errText)))
    {
        CComBSTR bstrError;
        bstrError.Attach(SysAllocStringLen(NULL, wcslen(errText) + SysStringLen(bstrName) + wcslen(m_wszObjName) + g_intBufferSize + g_intBufferSize));
        if (bstrError)
        {
            wsprintf(bstrError, errText, bstrName, m_wszObjName, vtExpected, vtGot);
            AtlReportError(CLSID_CDictionary, bstrError, IID_IDictionary, 0);
        }
    }
}

void CSmartHelperBase::ErrNoInterface(BSTR bstrName, LPCWSTR pwszInterface)
{
    WCHAR errText[g_maxErrorMsgSize];

    if (LoadString(HELPER_GETDLLINSTANCE_METHOD, IDS_DICTUTIL_ERRDICTINTERFACE , errText, sizeof(errText)))
    {
        CComBSTR bstrError;
        bstrError.Attach(SysAllocStringLen(NULL, wcslen(errText) + SysStringLen(bstrName) + wcslen(m_wszObjName) + wcslen(pwszInterface) + 10));
        if (bstrError)
        {
            wsprintf(bstrError, errText, bstrName, m_wszObjName, pwszInterface);
            AtlReportError(CLSID_CDictionary, bstrError, IID_IDictionary, 0);
        }
    }
}

void CSmartHelperBase::ErrMismatchedMoney(BSTR bstrName, BSTR bstrLegacyName)
{
    WCHAR errText[g_maxErrorMsgSize];

    if (LoadString(HELPER_GETDLLINSTANCE_METHOD, IDS_DICTUTIL_MISMATCHEDMONEY, errText, sizeof(errText)))
    {
        CComBSTR bstrError;
        bstrError.Attach(SysAllocStringLen(NULL, wcslen(errText) + SysStringLen(bstrName) + SysStringLen(bstrLegacyName)));
        if (bstrError)
        {
            wsprintf(bstrError, errText, bstrName, bstrLegacyName);
            AtlReportError(CLSID_CDictionary, bstrError, IID_IDictionary, 0);
        }
    }
}

// SimpleList errors


// an index less than zero means the index was unknown and is a different message
void CSmartHelperBase::ErrValueWrongType(long index, VARTYPE vtExpected, VARTYPE vtGot)
{
    WCHAR errText[g_maxErrorMsgSize];
    DWORD dwres = (index < 0) ? IDS_LISTHELPER_ERRLISTTYPENOINDEX : IDS_LISTHELPER_ERRLISTTYPE;

    if (LoadString(HELPER_GETDLLINSTANCE_METHOD, dwres, errText, sizeof(errText)))
    {
        CComBSTR bstrError;
        bstrError.Attach(SysAllocStringLen(NULL, wcslen(errText) + wcslen(m_wszObjName) + g_intBufferSize * 3));
        if (bstrError)
        {
            if (index < 0)
                wsprintf(bstrError, errText, m_wszObjName, vtExpected, vtGot);
            else
                wsprintf(bstrError, errText, index, m_wszObjName, vtExpected, vtGot);

            AtlReportError(CLSID_CDictionary, bstrError, IID_IDictionary, 0);
        }
    }
}

void CSmartHelperBase::ErrNoInterface(long index, LPCWSTR pwszInterface)
{
    WCHAR errText[g_maxErrorMsgSize];

    if (LoadString(HELPER_GETDLLINSTANCE_METHOD, IDS_LISTHELPER_ERRLISTINTERFACE , errText, sizeof(errText)))
    {
        CComBSTR bstrError;
        bstrError.Attach(SysAllocStringLen(NULL, wcslen(errText) + g_intBufferSize + wcslen(m_wszObjName) + wcslen(pwszInterface)));
        if (bstrError)
        {
            wsprintf(bstrError, errText, index, m_wszObjName, pwszInterface);
            AtlReportError(CLSID_CDictionary, bstrError, IID_IDictionary, 0);
        }
    }
}




//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//*****************************************************************************************
//=========================================================================================
//
//  CSmartDict implementation
//
//=========================================================================================
//*****************************************************************************************
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!


HRESULT CSmartDict::Create()
{
    if (m_pdict) m_pdict.Release();
    HRESULT hr = CoCreateInstance(CLSID_CDictionary, NULL, CLSCTX_INPROC_SERVER, IID_IDictionary, (void **)&m_pdict);
    if (FAILED(hr)) return hr;

    return S_OK;
}


// pass VT_EMPTY if no specific VARTYPE is required
//
HRESULT CSmartDict::GetValueBSTR(BSTR bstrName, VARIANT *pvarValue, VARTYPE vt, BOOL bOptional, BOOL bStrictType)
{
    _Assert(m_pdict);
    _Assert(bstrName);
    _Assert(pvarValue);

    HRESULT hr = S_OK;

    // make sure Init was called
    if (!m_pdict)
        return OLE_E_BLANK;

    // check parameters
    if (!bstrName || !pvarValue)
        return E_INVALIDARG;

    // get the value
    hr = m_pdict->get_Value(bstrName, pvarValue);
    if (FAILED(hr)) return hr;

    // check to see if it was null but required
    if (VT_NULL == V_VT(pvarValue))
    {
        if(bOptional)
        {
            return S_OK;
        }
        else
        {
            if (vt != VT_EMPTY)
            {
                // CleanUp: missing value with expected type
                this->ErrMissingValue(bstrName, vt);
                return E_FAIL;
            }
            else
            {
                // CleanUp: missing value with no type
                this->ErrMissingValue(bstrName);
                return E_FAIL;
            }
        }
    }

    // check the type if a strict type was requested
    if (bStrictType && V_VT(pvarValue) != vt)
    {
        // CleanUp: got value of wrong type
        this->ErrValueWrongType(bstrName, vt, V_VT(pvarValue));
        V_VT(pvarValue) = VT_NULL;
        V_I4(pvarValue) = 0;
        return E_FAIL;
    }

    // if it's not the right type, convert to the right type
    if (vt != VT_EMPTY && V_VT(pvarValue) != vt)
    {
        hr = ::VariantChangeType(pvarValue, pvarValue, 0, vt);
        if (FAILED(hr))
        {
            // got value of wrong type
            this->ErrValueWrongType(bstrName, vt, V_VT(pvarValue));
            V_VT(pvarValue) = VT_NULL;
            V_I4(pvarValue) = 0;
            return E_FAIL;
        }
    }

    return S_OK;
}

// get BSTR value
HRESULT CSmartDict::GetValueBSTR(BSTR bstrName, BSTR *pbstrValue, BOOL bOptional, BOOL *pbFound)
{
    _Assert(pbstrValue);
    if (!pbstrValue)
        return E_INVALIDARG;

    VARIANT var;
    HRESULT hr = S_OK;

    *pbstrValue = NULL;
    if (pbFound) *pbFound = TRUE;

    V_VT(&var) = VT_EMPTY;
    hr = this->GetValueBSTR(bstrName, &var, VT_BSTR, bOptional);
    if (FAILED(hr)) return hr;

    if (VT_NULL==V_VT(&var))
    {
        if (pbFound) *pbFound = FALSE;
        if (!bOptional)
        {
            ErrMissingValue(bstrName, VT_BSTR);
            return E_FAIL;
        }
    }
    else
    {
        *pbstrValue = V_BSTR(&var);
    }

    return hr;
}

HRESULT CSmartDict::GetValueBSTR(BSTR bstrName, int *pintValue, BOOL bOptional, BOOL *pbFound)
{
    _Assert(pintValue);
    if (!pintValue)
        return E_INVALIDARG;

    VARIANT var;
    HRESULT hr = S_OK;

    if (pbFound) *pbFound = TRUE;

    V_VT(&var) = VT_EMPTY;
    hr = this->GetValueBSTR(bstrName, &var, VT_I4, bOptional);
    if (FAILED(hr)) return hr;

    if (VT_NULL==V_VT(&var))
    {
        if (pbFound) *pbFound = FALSE;
        if (!bOptional)
        {
            ErrMissingValue(bstrName, VT_I4);
            return E_FAIL;
        }
    }
    else
    {
        *pintValue = V_I4(&var);
    }

    return hr;
}

HRESULT CSmartDict::GetValueBSTR(BSTR bstrName, long *plongValue, BOOL bOptional, BOOL *pbFound)
{
    _Assert(plongValue);
    if (!plongValue)
        return E_INVALIDARG;

    VARIANT var;
    HRESULT hr = S_OK;

    if (pbFound) *pbFound = TRUE;

    V_VT(&var) = VT_EMPTY;
    hr = this->GetValueBSTR(bstrName, &var, VT_I4, bOptional);
    if (FAILED(hr)) return hr;

    if (VT_NULL==V_VT(&var))
    {
        if (pbFound) *pbFound = FALSE;
        if (!bOptional)
        {
            ErrMissingValue(bstrName, VT_I4);
            return E_FAIL;
        }
    }
    else
    {
        *plongValue = V_I4(&var);
    }

    return hr;
}

HRESULT CSmartDict::GetValueBSTR(BSTR bstrName, short *pshortValue, BOOL bOptional, BOOL *pbFound)
{
    _Assert(pshortValue);
    if (!pshortValue)
        return E_INVALIDARG;

    VARIANT var;
    HRESULT hr = S_OK;

    if (pbFound) *pbFound = TRUE;

    V_VT(&var) = VT_EMPTY;
    hr = this->GetValueBSTR(bstrName, &var, VT_I2, bOptional);
    if (FAILED(hr)) return hr;

    if (VT_NULL==V_VT(&var))
    {
        if (pbFound) *pbFound = FALSE;
        if (!bOptional)
        {
            ErrMissingValue(bstrName, VT_I2);
            return E_FAIL;
        }
    }
    else
    {
        *pshortValue = V_I2(&var);
    }

    return hr;
}

HRESULT CSmartDict::GetValueBSTR(BSTR bstrName, float *pfloatValue, BOOL bOptional, BOOL *pbFound)
{
    _Assert(pfloatValue);
    if (!pfloatValue)
        return E_INVALIDARG;

    VARIANT var;
    HRESULT hr = S_OK;

    if (pbFound) *pbFound = TRUE;

    V_VT(&var) = VT_EMPTY;
    hr = this->GetValueBSTR(bstrName, &var, VT_R4, bOptional);
    if (FAILED(hr)) return hr;

    if (VT_NULL==V_VT(&var))
    {
        if (pbFound) *pbFound = FALSE;
        if (!bOptional)
        {
            ErrMissingValue(bstrName, VT_R4);
            return E_FAIL;
        }
    }
    else
    {
        *pfloatValue = V_R4(&var);
    }

    return hr;

}

HRESULT CSmartDict::GetValueBSTR(BSTR bstrName, double *pdoubleValue, BOOL bOptional, BOOL *pbFound)
{
    _Assert(pdoubleValue);
    if (!pdoubleValue)
        return E_INVALIDARG;

    VARIANT var;
    HRESULT hr = S_OK;

    if (pbFound) *pbFound = TRUE;

    V_VT(&var) = VT_EMPTY;
    hr = this->GetValueBSTR(bstrName, &var, VT_R8, bOptional);
    if (FAILED(hr)) return hr;

    if (VT_NULL==V_VT(&var))
    {
        if (pbFound) *pbFound = FALSE;
        if (!bOptional)
        {
            ErrMissingValue(bstrName, VT_R8);
            return E_FAIL;
        }
    }
    else
    {
        *pdoubleValue = V_R8(&var);
    }

    return hr;

}

HRESULT CSmartDict::GetValueBSTR(BSTR bstrName, BSTR bstrLegacyName, CURRENCY *pcyValue, BOOL bOptional, BOOL *pbFound)
{
    _Assert(pcyValue);
    _Assert(m_pMoneyInfo);

    if (!pcyValue)
        return E_INVALIDARG;

    HRESULT hr = S_OK;
    VARIANT var;
    VARIANT varLegacy;
    V_VT(&var) = VT_EMPTY;
    V_VT(&varLegacy) = VT_EMPTY;
    int nPennies;
    BOOL bFoundInt;
    BOOL bFoundCurrency;

    if (pbFound) *pbFound = TRUE;

    if (3 == m_pMoneyInfo->GetMode()) // compatibility mode -- existence matrix...
    {
        if (FAILED(hr = this->GetValueBSTR(bstrName, &var, VT_CY, Optional)))
            goto CleanUp;
        if (FAILED(hr = this->GetValueBSTR(bstrLegacyName, &varLegacy, VT_I4, Optional)))
            goto CleanUp;

        bFoundCurrency = ( VT_NULL != V_VT(&var) );
        bFoundInt = ( VT_NULL != V_VT(&varLegacy) );

        if (!bFoundInt && !bFoundCurrency)  // neither key found
        {
            if (!bOptional)
            {
                ErrMissingValue(bstrName, VT_CY);
                if (FAILED(hr = E_FAIL))
                    goto CleanUp;
            }
        }
        else if (bFoundInt && bFoundCurrency)  // both keys found
        {
            // ensure that the keys are equiv
            if (FAILED(hr = m_pMoneyInfo->CurrencyToInt(V_CY(&var), nPennies, bstrLegacyName)))
                goto CleanUp;
            if (V_I4(&varLegacy) != nPennies)
            {
                ErrMismatchedMoney(bstrName, bstrLegacyName);
                if (FAILED(hr = E_FAIL))
                    goto CleanUp;
            }
        }
        else if (bFoundInt && !bFoundCurrency)  // integer found
        {
            // convert and propogate to the currency key...
            V_VT(&var) = VT_CY;
            if (FAILED(hr = m_pMoneyInfo->IntToCurrency(V_I4(&varLegacy), V_CY(&var))))
                goto CleanUp;
            if (FAILED(hr = this->PutValue(bstrName, &var)))
                goto CleanUp;
        }
        else if (!bFoundInt && bFoundCurrency)  // currency was found
        {
            // convert and propogate to the legacy key...
            V_VT(&varLegacy) = VT_I4;
            if (FAILED(hr = m_pMoneyInfo->CurrencyToInt(V_CY(&var), (int&)V_I4(&varLegacy), bstrLegacyName)))
                goto CleanUp;
            if (FAILED(hr = this->PutValue(bstrLegacyName, &varLegacy)))
                goto CleanUp;
        }
    }
    else
    {
        if (FAILED(hr = this->GetValueBSTR(bstrName, &var, VT_CY, bOptional)))
            goto CleanUp;
    }

    if (VT_NULL==V_VT(&var))
    {
        if (pbFound) *pbFound = FALSE;
    }
    else
    {
        *pcyValue = V_CY(&var);
    }

CleanUp:
    return hr;
}


// get IDispatch value
HRESULT CSmartDict::GetValueBSTR(BSTR bstrName, IDispatch **ppdispValue, BOOL bOptional, BOOL *pbFound)
{
    _Assert(ppdispValue);
    if (!ppdispValue)
        return E_INVALIDARG;

    VARIANT var[1];
    HRESULT hr = S_OK;

    *ppdispValue = NULL;
    if (pbFound) *pbFound = TRUE;

    V_VT(var) = VT_EMPTY;
    hr = this->GetValueBSTR(bstrName, var, VT_DISPATCH, bOptional, StrictType);
    if (FAILED(hr)) return hr;

    if (VT_NULL==V_VT(var))
    {
        if (pbFound) *pbFound = FALSE;
        if (!bOptional)
        {
            ErrMissingValue(bstrName, VT_DISPATCH);
            return E_FAIL;
        }
    }
    else
    {
        *ppdispValue = V_DISPATCH(var);
    }

    return hr;
}

// get IUnknown value
HRESULT CSmartDict::GetValueBSTR(BSTR bstrName, IUnknown **ppunkValue, BOOL bOptional, BOOL *pbFound)
{
    _Assert(ppunkValue);
    if (!ppunkValue)
        return E_INVALIDARG;

    VARIANT var[1];
    HRESULT hr = S_OK;

    *ppunkValue = NULL;
    if (pbFound) *pbFound = TRUE;

    V_VT(var) = VT_EMPTY;
    hr = this->GetValueBSTR(bstrName, var, VT_UNKNOWN, bOptional, StrictType);
    if (FAILED(hr)) return hr;

    if (VT_NULL==V_VT(var))
    {
        if (!bOptional)
        {
            ErrMissingValue(bstrName, VT_UNKNOWN);
            return E_FAIL;
        }
        if (pbFound) *pbFound = FALSE;
    }
    else
    {
        *ppunkValue = V_UNKNOWN(var);
    }

    return hr;
}

// get IDictionary value
HRESULT CSmartDict::GetValueBSTR(BSTR bstrName, IDictionary **ppdictValue, BOOL bOptional, BOOL *pbFound)
{
    _Assert(ppdictValue);
    if (!ppdictValue)
        return E_INVALIDARG;

    CComVariant var;
    HRESULT hr = S_OK;

    *ppdictValue = NULL;
    if (pbFound) *pbFound = TRUE;

    hr = this->GetValueBSTR(bstrName, &var, VT_DISPATCH, bOptional, StrictType);
    if (FAILED(hr)) return hr;

    if (VT_NULL==V_VT(&var))
    {
        if (pbFound) *pbFound = FALSE;
        if (!bOptional)
        {
            ErrMissingValue(bstrName, VT_DISPATCH);
            return E_FAIL;
        }
    }
    else
    {
        hr = V_DISPATCH(&var)->QueryInterface(IID_IDictionary, (void **)ppdictValue);
        if (E_NOINTERFACE==hr)
            ErrNoInterface(bstrName, L"IDictionary");
    }

    return hr;
}

// get ISimpleList value
HRESULT CSmartDict::GetValueBSTR(BSTR bstrName, ISimpleList **pplistValue, BOOL bOptional, BOOL *pbFound)
{
    _Assert(pplistValue);
    if (!pplistValue)
        return E_INVALIDARG;

    CComVariant var;
    HRESULT hr = S_OK;

    *pplistValue = NULL;
    if (pbFound) *pbFound = TRUE;

    hr = this->GetValueBSTR(bstrName, &var, VT_DISPATCH, bOptional, StrictType);
    if (FAILED(hr)) return hr;

    if (VT_NULL==V_VT(&var))
    {
        if (pbFound) *pbFound = FALSE;
        if (!bOptional)
        {
            ErrMissingValue(bstrName, VT_DISPATCH);
            return E_FAIL;
        }
    }
    else
    {
        hr = V_DISPATCH(&var)->QueryInterface(IID_ISimpleList, (void **)pplistValue);
        if (E_NOINTERFACE==hr)
            ErrNoInterface(bstrName, L"ISimpleList");
    }

    return hr;
}


HRESULT CSmartDict::GetValueBSTR(BSTR bstrName, CSmartDict &rdict, BOOL bOptional, BOOL *pbFound)
{
    HRESULT hr = S_OK;
    BOOL bFound;
    BOOL *pb = pbFound ? pbFound : &bFound;

    IDictionary* pdict;
    if (FAILED(hr = this->GetValueBSTR(bstrName, &pdict, bOptional, pb)))
        goto CleanUp;
    if (!bOptional || (bOptional && *pb))
    {
        if (m_pMoneyInfo)
        {
            rdict.Init((IDictionary*)NULL, bstrName, m_pMoneyInfo);
        }
        else
        {
            rdict.Init((IDictionary*)NULL, bstrName, m_wszCompId, m_pdispContext);
        }
        rdict.Attach(pdict);
    }

CleanUp:
    return hr;
}

HRESULT CSmartDict::GetValueBSTR(BSTR bstrName, CSmartList &rlist, BOOL bOptional, BOOL *pbFound)
{
    HRESULT hr = S_OK;
    BOOL bFound;
    BOOL *pb = pbFound ? pbFound : &bFound;

    ISimpleList* plist;
    if (FAILED(hr = this->GetValueBSTR(bstrName, &plist, bOptional, pb)))
        goto CleanUp;
    if (!bOptional || (bOptional && *pb))
    {
        if (m_pMoneyInfo)
        {
            rlist.Init((ISimpleList*)NULL, bstrName, m_pMoneyInfo);
        }
        else
        {
            rlist.Init((ISimpleList*)NULL, bstrName, m_wszCompId, m_pdispContext);
        }
        rlist.Attach(plist);
    }

CleanUp:
    return hr;
}

// ICloneable

HRESULT CSmartDict::Clone(CSmartDict &rClone)
{
    _Assert(m_pdict);
    if (!m_pdict)
        return OLE_E_BLANK;

    HRESULT hr = S_OK;
    CComPtr<IDictionary> pdictClone;
    if (FAILED(hr = this->Clone(&pdictClone)))
        goto CleanUp;
    rClone.CopyBase(*this);
    rClone.SetDict(pdictClone);
CleanUp:
    return hr;
}

HRESULT CSmartDict::Clone(IDictionary **ppdictClone)
{
    _Assert(m_pdict);
    _Assert(ppdictClone);
    if (!ppdictClone)
        return E_INVALIDARG;
    if (!m_pdict)
        return OLE_E_BLANK;

    HRESULT hr = S_OK;
    CComPtr<ICloneable> pCloneSource, pCloneDest;
    if (FAILED(hr = m_pdict->QueryInterface(IID_ICloneable, (void**)&pCloneSource)))
        goto CleanUp;
    if (FAILED(hr = pCloneSource->Clone(&pCloneDest)))
        goto CleanUp;
    if (FAILED(hr = pCloneDest->QueryInterface(IID_IDictionary, (void**)ppdictClone)))
        goto CleanUp;
CleanUp:
    return hr;
}

// enumerations

HRESULT CSmartDict::GetNewEnum()
{
    _Assert(m_pdict);
    if (!m_pdict) return OLE_E_BLANK;

    HRESULT             hr = S_OK;
    CComPtr<IUnknown>   punk;

    hr = m_pdict->get__NewEnum(&punk);
    if (FAILED(hr)) return hr;

    if (m_penumVariant)   m_penumVariant.Release() ;
    hr = punk->QueryInterface(IID_IEnumVARIANT, (void**)&m_penumVariant);
    if (FAILED(hr)) return hr;

    return S_OK;
}


BOOL CSmartDict::GetNextKey(BSTR *pbstr, HRESULT *phr)
{
    _Assert(m_pdict);
    _Assert(pbstr);
    _Assert(m_penumVariant);

    HRESULT hr = S_OK;
    CComVariant var;

    if (!m_penumVariant)
    {
        hr = OLE_E_ENUM_NOMORE;
        goto CleanUp;
    }

    if (!pbstr)
    {
        hr = E_INVALIDARG;
        goto CleanUp;
    }

    if (!m_pdict)
    {
        hr = OLE_E_BLANK;
        goto CleanUp;
    }

    hr = m_penumVariant->Next(1, &var, NULL);
    if (hr != S_OK)
    {
        m_penumVariant.Release();
        goto CleanUp;
    }

    if (V_VT(&var) != VT_BSTR)      // should never happen since dicts are keyed by BSTRs
    {
        hr = DISP_E_TYPEMISMATCH;
        goto CleanUp;
    }

    *pbstr = V_BSTR(&var);
    V_VT(&var) = VT_EMPTY;

// Success:
    if (phr) *phr = S_OK;
    return TRUE;

CleanUp:
    if (phr)
    {
        if (FAILED(hr))
            *phr = hr;
        else
            *phr = S_OK;
    }
    if (pbstr) *pbstr = NULL;
    return FALSE;
}




//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//*****************************************************************************************
//=========================================================================================
//
//  CSmartList implementation
//
//=========================================================================================
//*****************************************************************************************
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

HRESULT CSmartList::Create()
{
    if (m_plist) m_plist.Release();
    HRESULT hr = CoCreateInstance(CLSID_CSimpleList, NULL, CLSCTX_INPROC_SERVER, IID_ISimpleList, (void **)&m_plist);
    if (FAILED(hr)) return hr;

    return S_OK;
}


HRESULT CSmartList::GetItem(long index, VARIANT *pvarValue, VARTYPE vt, BOOL bStrictType)
{
   HRESULT hr = S_OK;

    // make sure Init was called
    if (!m_plist) return OLE_E_BLANK;

    // check parameters
    if (!pvarValue) return E_POINTER;

    // get the value
    hr = m_plist->get_Item(index, pvarValue);
    if (FAILED(hr)) return hr;

    // check the type if a strict type was requested
    if (bStrictType && V_VT(pvarValue) != vt)
    {
        // got value of wrong type
        this->ErrValueWrongType(index, vt, V_VT(pvarValue));
        V_VT(pvarValue) = VT_NULL;
        V_I4(pvarValue) = 0;
        return E_FAIL;
    }

    // if it's not the right type, convert to the right type
    if (vt != VT_EMPTY && V_VT(pvarValue) != vt)
    {
        hr = ::VariantChangeType(pvarValue, pvarValue, 0, vt);
        if (FAILED(hr))
        {
            // got value of wrong type
            this->ErrValueWrongType(index, vt, V_VT(pvarValue));
            V_VT(pvarValue) = VT_NULL;
            V_I4(pvarValue) = 0;
            return E_FAIL;
        }
    }

    return S_OK;
}

HRESULT CSmartList::GetItem(long index, IDictionary **ppdictValue)
{
    CComVariant var;
    HRESULT hr = S_OK;
    if (!ppdictValue) return E_POINTER;
    if (FAILED(hr = this->GetItem(index, &var, VT_DISPATCH, StrictType)))
        return hr;
    hr = V_DISPATCH(&var)->QueryInterface(IID_IDictionary, (void **)ppdictValue);
    if (E_NOINTERFACE==hr)
    {
        this->ErrNoInterface(index, L"IDictionary");
    }
    return hr;
}

HRESULT CSmartList::GetItem(long index, ISimpleList **pplistValue)
{
    CComVariant var;
    HRESULT hr = S_OK;
    if (!pplistValue) return E_POINTER;
    if (FAILED(hr = this->GetItem(index, &var, VT_DISPATCH, StrictType)))
        return hr;
    hr = V_DISPATCH(&var)->QueryInterface(IID_ISimpleList, (void **)pplistValue);
    if (E_NOINTERFACE==hr)
    {
        this->ErrNoInterface(index, L"ISimpleList");
    }
    return hr;
}



// ICloneable

HRESULT CSmartList::Clone(CSmartList &rClone)
{
    _Assert(m_plist);
    if (!m_plist) return OLE_E_BLANK;

    HRESULT hr = S_OK;
    CComPtr<ISimpleList> plistClone;
    if (FAILED(hr = this->Clone(&plistClone)))
        goto CleanUp;
    rClone.CopyBase(*this);
    rClone.SetList(plistClone);
CleanUp:
    return hr;
}

HRESULT CSmartList::Clone(ISimpleList **pplistClone)
{
    _Assert(m_plist);
    _Assert(pplistClone);
    if (!pplistClone) return E_POINTER;
    if (!m_plist) return OLE_E_BLANK;

    HRESULT hr = S_OK;
    CComPtr<ICloneable> pCloneSource, pCloneDest;
    if (FAILED(hr = m_plist->QueryInterface(IID_ICloneable, (void**)&pCloneSource)))
        goto CleanUp;
    if (FAILED(hr = pCloneSource->Clone(&pCloneDest)))
        goto CleanUp;
    if (FAILED(hr = pCloneDest->QueryInterface(IID_ISimpleList, (void**)pplistClone)))
        goto CleanUp;
CleanUp:
    return hr;
}


// IEnumVARIANT

HRESULT CSmartList::GetNewEnum(VARTYPE vt, BOOL bStrictType)
{
    _Assert(m_plist);
    if (!m_plist) return OLE_E_BLANK;

    HRESULT             hr = S_OK;
    CComPtr<IUnknown>   punk;

    m_enumVarType = vt;
    hr = m_plist->get__NewEnum(&punk);
    if (FAILED(hr)) return hr;

    if (m_penumVariant)   m_penumVariant.Release() ;
    hr = punk->QueryInterface(IID_IEnumVARIANT, (void**)&m_penumVariant);
    if (FAILED(hr)) return hr;

    m_enumPosition = -1;

    return S_OK;
}


BOOL CSmartList::GetNextItem(VARIANT *pvar, HRESULT *phr)
{
    _Assert(m_plist);
    _Assert(m_penumVariant);
    _Assert(pvar);

    HRESULT hr = S_OK;
    m_enumPosition = m_enumPosition + 1;

    if (!m_penumVariant)
    {
        hr = OLE_E_ENUM_NOMORE;
        goto CleanUp;
    }

    if (!pvar)
    {
        hr = E_POINTER;
        goto CleanUp;
    }
    V_VT(pvar) = VT_EMPTY;

    if (!m_plist)
    {
        hr = OLE_E_BLANK;
        goto CleanUp;
    }

    hr = m_penumVariant->Next(1, pvar, NULL);
    if (hr != S_OK)
    {
        m_penumVariant.Release();
        goto CleanUp;
    }

    // make sure the variant we got is the type we wanted!
    if (m_enumVarType != VT_EMPTY && V_VT(pvar) != m_enumVarType)
    {
        if (FAILED(hr = ::VariantChangeType(pvar, pvar, 0, m_enumVarType)))
        {
            // CleanUp: variant is not of the expected type
            this->ErrValueWrongType(-1, m_enumVarType, V_VT(pvar));
            return DISP_E_TYPEMISMATCH;
        }
    }

// Success:
    if (phr) *phr = S_OK;

    return TRUE;

CleanUp:
    if (phr)
    {
        if (FAILED(hr))
            *phr = hr;
        else
            *phr = S_OK;
    }
    if (pvar) { V_VT(pvar) = VT_NULL; V_I4(pvar) = 0; }
    return FALSE;
}

BOOL CSmartList::GetNextItem(CSmartDict &rdict, HRESULT *phr)
{
    HRESULT hr = S_OK;
    CComVariant var;

    CComBSTR cbstrDictName;
    CComVariant varPosition(m_enumPosition);
    if (FAILED(hr = varPosition.ChangeType(VT_BSTR)))
        goto CleanUp;

    if (!GetNextItem(&var, &hr))
        goto CleanUp;

    cbstrDictName.Append(m_wszObjName);
    cbstrDictName.Append("(");
    cbstrDictName.AppendBSTR(V_BSTR(&varPosition));
    cbstrDictName.Append(")");

    if (FAILED(hr = rdict.Init(&var, cbstrDictName, (CSmartHelperBase)*this)))
        goto CleanUp;

    return TRUE;

CleanUp:
    if (phr)
    {
        if (FAILED(hr))
            *phr = hr;
        else
            *phr = S_OK;
    }
    return FALSE;
}

